package com.sojson.project.sys.dict.service.impl;

import java.io.IOException;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sojson.enums.core.EGeneralYesNo;
import com.sojson.project.sys.dict.dao.DictDataDao;
import com.sojson.project.sys.dict.entity.dto.DictDataDto;
import com.sojson.project.sys.dict.entity.dto.DictDataPageDto;
import com.sojson.project.sys.dict.entity.po.DictData;
import com.sojson.project.sys.dict.entity.vo.DictDataVo;
import com.sojson.project.sys.dict.service.DictDataService;
import com.sojson.util.DictUtil;
import com.sojson.util.ExpUtil;
import com.sojson.util.StringUtil;

/**
 * 字典类型描述表Service实现类
 * 
 * @author liu
 * @date 2022-09-07
 */
@Service
public class DictDataServiceImpl extends ServiceImpl<DictDataDao, DictData> implements DictDataService {

    @Resource
    private DictDataDao dictDataDao;

    /**
     * 单条插入
     * 
     * @param dto
     * @return
     * @throws IOException 
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean add(DictData dto) throws IOException {
        // 修改默认状态
        if (StringUtil.isBlankObject(dto.getIsDefault())) {
            // 查看此code是否存在
            LambdaQueryWrapper<DictData> query = Wrappers.lambdaQuery(DictData.class);
            query.eq(DictData::getCode, dto.getCode());
            int count = count(query);

            if (count > 0) {
                dto.setIsDefault(EGeneralYesNo.NO.getCode());
            } else {
                dto.setIsDefault(EGeneralYesNo.YES.getCode());
            }
        }

        // 去重
        LambdaQueryWrapper<DictData> query = Wrappers.lambdaQuery(DictData.class);
        query.eq(DictData::getCode, dto.getCode());
        query.eq(DictData::getVal, dto.getVal());
        int count = count(query);
        if (count > 0) {
            ExpUtil.throwEx("值已存在!");
        }

        // 如果设为默认,就将其他的设为非默认
        if (EGeneralYesNo.YES.getCode() == dto.getIsDefault()) {
            dictDataDao.updateDefaultByCode(dto.getCode(), EGeneralYesNo.NO.getCode());
        }

        dictDataDao.insert(dto);

        // 更新缓存
        String code = dto.getCode();
        List<DictDataVo> findByKey = dictDataDao.findByKey(code);
        if (findByKey != null && findByKey.size() > 0) {
            DictUtil.put(code, findByKey);
        }
        return true;
    }

    /**
     * 通过id更新
     * 
     * @param dto
     * @return
     * @throws IOException 
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean update(DictData dto) throws IOException {
        // 去重
        LambdaQueryWrapper<DictData> query = Wrappers.lambdaQuery(DictData.class);
        query.ne(DictData::getId, dto.getId());
        query.eq(DictData::getCode, dto.getCode());
        query.eq(DictData::getVal, dto.getVal());
        int count = count(query);
        if (count > 0) {
            ExpUtil.throwEx("值已存在!");
        }

        // 如果设为默认,就将其他的设为非默认
        if (EGeneralYesNo.YES.getCode() == dto.getIsDefault()) {
            dictDataDao.updateDefaultByCode(dto.getCode(), EGeneralYesNo.NO.getCode());
        }

        String code = dto.getCode();
        dto.updateInit();
        dictDataDao.updateById(dto);

        // 更新缓存
        List<DictDataVo> findByKey = dictDataDao.findByKey(code);
        if (findByKey != null && findByKey.size() > 0) {
            DictUtil.put(code, findByKey);
        }
        return true;
    }

    /**
     * 列表查询
     * 
     * @param dto
     * @return
     */
    @Override
    public List<DictDataVo> list(DictDataDto dto) {
        List<DictDataVo> list = dictDataDao.list(dto);
        return list;
    }

    /**
     * 分页查询
     * 
     * @param dto
     * @return
     */
    @Override
    public List<DictDataVo> page(DictDataPageDto dto) {
        List<DictDataVo> page = dictDataDao.page(dto);
        return page;
    }

    /**
     * 通过id查询
     * 
     * @param id
     * @return
     */
    @Override
    public DictDataVo findById(String id) {
        return dictDataDao.findById(id);
    }

    /**
     * 通过key查询
     * 
     * @param key
     * @return
     * @throws IOException 
     */
    @Override
    public List<DictDataVo> findByKey(String key) throws IOException {
        return dictDataDao.findByKey(key);
    }

    /**
     * 通过对象删除
     * 
     * @param dto
     * @return
     */
    @Override
    public boolean removeByDto(DictDataDto dto) {
        dictDataDao.removeByDto(dto);
        return true;
    }

    /**
     * 通过id列表删除
     * 
     * @param ids
     * @return
     * @throws IOException 
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean removeByIds(List<String> ids) throws IOException {
        List<DictData> listByIds = listByIds(ids);

        dictDataDao.deleteBatchIds(ids);
        if (listByIds == null || listByIds.size() < 1) {
            return true;
        }

        // 更新缓存
        String code = listByIds.get(0).getCode();
        List<DictDataVo> findByKey = dictDataDao.findByKey(code);
        if (findByKey != null && findByKey.size() > 0) {
            DictUtil.put(code, findByKey);
        }
        return true;
    }

    /**
     * 清空数据
     * 
     * @return
     */
    @Override
    public boolean clear() {
        dictDataDao.clear();
        return true;
    }

    /**
     * 修改默认状态
     * 
     * @param code
     * @param val
     */
    @Override
    public boolean updateDefaultByCode(String code, int val) {
        dictDataDao.updateDefaultByCode(code, val);
        return true;
    }

}